/**
 * 认证API服务
 * 
 * 功能说明：
 * - 用户登录/注册
 * - Token验证/刷新
 * - 密码重置
 * - 邮箱验证
 */

import apiClient from './api'

/**
 * 认证服务类
 */
class AuthService {
  /**
   * 用户登录
   * 
   * @param {Object} credentials - 登录凭据
   * @param {string} credentials.email - 邮箱或用户名
   * @param {string} credentials.password - 密码
   * @returns {Promise<Object>} 登录结果
   */
  async login(credentials) {
    try {
      console.log('前端提交的登录凭据:', credentials);
      // 转换字段名：后端API期望username字段而不是email字段
      const loginData = {
        username: credentials.email, // 用email值作为username字段
        password: credentials.password
      }
      console.log('转换后发送给后端的数据:', loginData);
      const response = await apiClient.post('/api/auth/login', loginData)
      console.log('登录API响应:', response);
      return response.data
    } catch (error) {
      console.error('登录API调用错误:', error);
      if (error.response) {
        console.error('响应状态:', error.response.status);
        console.error('响应数据:', error.response.data);
      }
      throw this.handleError(error, '登录失败')
    }
  }

  /**
   * 用户注册
   * 
   * @param {Object} userData - 注册数据
   * @param {string} userData.username - 用户名
   * @param {string} userData.email - 邮箱
   * @param {string} userData.password - 密码

   * @returns {Promise<Object>} 注册结果
   */
  async register(userData) {
    try {
      const response = await apiClient.post('/api/auth/register', userData)
      return response.data
    } catch (error) {
      throw this.handleError(error, '注册失败')
    }
  }

  /**
   * 用户注销
   * 
   * @returns {Promise<Object>} 注销结果
   */
  async logout() {
    try {
      const response = await apiClient.post('/api/auth/logout')
      return response.data
    } catch (error) {
      // 注销失败不阻塞，只记录日志
      console.error('注销API调用失败:', error)
      return { success: true }
    }
  }

  /**
   * 验证token有效性
   * 
   * @returns {Promise<Object>} 验证结果
   */
  async verifyToken() {
    try {
      const response = await apiClient.get('/api/auth/verify')
      return response.data
    } catch (error) {
      throw this.handleError(error, 'Token验证失败')
    }
  }

  /**
   * 刷新访问token
   * 
   * @param {string} refreshToken - 刷新token
   * @returns {Promise<Object>} 新的token
   */
  async refreshToken(refreshToken) {
    try {
      const response = await apiClient.post('/api/auth/refresh', { refresh_token: refreshToken })
      return response.data
    } catch (error) {
      throw this.handleError(error, 'Token刷新失败')
    }
  }

  /**
   * 发送邮箱验证链接
   * 
   * @param {string} email - 邮箱地址
   * @returns {Promise<Object>} 发送结果
   */
  async sendEmailVerification(email) {
    try {
      const response = await apiClient.post('/api/auth/send-verification', { email })
      return response.data
    } catch (error) {
      throw this.handleError(error, '验证邮件发送失败')
    }
  }

  /**
   * 验证邮箱
   * 
   * @param {string} token - 验证token
   * @returns {Promise<Object>} 验证结果
   */
  async verifyEmail(token) {
    try {
      const response = await apiClient.post('/api/auth/verify-email', { token })
      return response.data
    } catch (error) {
      throw this.handleError(error, '邮箱验证失败')
    }
  }

  /**
   * 修改密码
   * 
   * @param {Object} passwordData - 密码数据
   * @param {string} passwordData.currentPassword - 当前密码
   * @param {string} passwordData.newPassword - 新密码
   * @returns {Promise<Object>} 修改结果
   */
  async changePassword(passwordData) {
    try {
      const response = await apiClient.post('/api/auth/change-password', passwordData)
      return response.data
    } catch (error) {
      throw this.handleError(error, '密码修改失败')
    }
  }

  /**
   * 获取用户信息
   * 
   * @returns {Promise<Object>} 用户信息
   */
  async getCurrentUser() {
    try {
      const response = await apiClient.get('/api/users/me')
      return response.data
    } catch (error) {
      throw this.handleError(error, '获取用户信息失败')
    }
  }

  /**
   * 更新用户信息
   * 
   * @param {Object} userData - 用户数据
   * @returns {Promise<Object>} 更新结果
   */
  async updateProfile(userData) {
    try {
      const response = await apiClient.patch('/api/auth/me', userData)
      return response.data
    } catch (error) {
      throw this.handleError(error, '更新用户信息失败')
    }
  }

  /**
   * 上传用户头像
   * 
   * @param {File} file - 头像文件
   * @param {Function} onProgress - 上传进度回调
   * @returns {Promise<Object>} 上传结果
   */
  async uploadAvatar(file, onProgress) {
    try {
      const formData = new FormData()
      formData.append('avatar', file)
      
      const response = await apiClient.post('/api/auth/avatar', formData, {
        headers: {
          'Content-Type': 'multipart/form-data'
        },
        onUploadProgress: onProgress
      })
      return response.data
    } catch (error) {
      throw this.handleError(error, '头像上传失败')
    }
  }

  // ==================== 工具方法 ====================

  /**
   * 设置请求头的认证token
   * 
   * @param {string} token - 访问token
   */
  setAuthHeader(token) {
    if (token) {
      apiClient.defaults.headers.common['Authorization'] = `Bearer ${token}`
    }
  }

  /**
   * 清除请求头的认证token
   */
  clearAuthHeader() {
    delete apiClient.defaults.headers.common['Authorization']
  }

  /**
   * 错误处理
   * 
   * @param {Object} error - 错误对象
   * @param {string} defaultMessage - 默认错误消息
   * @returns {Object} 处理后的错误
   */
  handleError(error, defaultMessage) {
    if (error.response?.data) {
      return {
        message: error.response.data.message || defaultMessage,
        status: error.response.status,
        data: error.response.data
      }
    }
    
    return {
      message: error.message || defaultMessage,
      status: 0,
      data: null
    }
  }

  /**
   * 检查邮箱格式
   * 
   * @param {string} email - 邮箱地址
   * @returns {boolean} 是否有效
   */
  isValidEmail(email) {
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
    return emailRegex.test(email)
  }

  /**
   * 检查密码强度
   * 
   * @param {string} password - 密码
   * @returns {Object} 强度检查结果
   */
  checkPasswordStrength(password) {
    const result = {
      isValid: false,
      score: 0,
      feedback: []
    }

    if (password.length < 6) {
      result.feedback.push('密码长度至少6位')
      return result
    }

    if (password.length >= 8) result.score += 1
    if (/[a-z]/.test(password)) result.score += 1
    if (/[A-Z]/.test(password)) result.score += 1
    if (/[0-9]/.test(password)) result.score += 1
    if (/[^A-Za-z0-9]/.test(password)) result.score += 1

    result.isValid = result.score >= 2

    if (result.score < 2) {
      result.feedback.push('密码应包含字母和数字')
    } else if (result.score < 3) {
      result.feedback.push('建议包含大小写字母')
    } else if (result.score < 4) {
      result.feedback.push('建议包含特殊字符')
    }

    return result
  }

  /**
   * 请求密码重置
   * 
   * @param {string} email - 用户邮箱
   * @returns {Promise<Object>} 请求结果
   */
  async requestPasswordReset(email) {
    try {
      const response = await apiClient.post('/api/auth/forgot-password', { email })
      return response.data
    } catch (error) {
      throw this.handleError(error, '请求密码重置失败')
    }
  }

  /**
   * 重置密码
   * 
   * @param {Object} resetData - 重置密码数据
   * @param {string} resetData.token - 重置密码token
   * @param {string} resetData.newPassword - 新密码
   * @param {string} resetData.confirmPassword - 确认新密码
   * @returns {Promise<Object>} 重置结果
   */
  async resetPassword(resetData) {
    try {
      const response = await apiClient.post('/api/auth/reset-password', resetData)
      return response.data
    } catch (error) {
      throw this.handleError(error, '重置密码失败')
    }
  }
}

// 导出单例实例
const authService = new AuthService()
export default authService 